Eh? Intent means nothing here. The standard requires int main. Who cares what you intend to do?If you never intend to return, void main is just fine. Otherwise, you have no reason to use void main.
Eh? Intent means nothing here. The standard requires int main. Who cares what you intend to do?If you never intend to return, void main is just fine. Otherwise, you have no reason to use void main.
The funny thing is that if you never intend to explicitly return from the global main function, int main is just fine. The use of void main, on the other hand, may result in a compile error.Originally Posted by User Name:
Look up a C++ Reference and learn How To Ask Questions The Smart Way
No question that, if your compiler supports void main(), you are allowed to use it.
Also correct that a compiler which supports entry points other than int main() might be properly characterised as a freestanding implementation. There is also nothing in the standard preventing an implementation from being both freestanding and hosted - the difference between those two terms comes down to the minimum set of libraries that must be supported, not to the extensions supported.
However, an implementation (compiler and library) that supports void main() is only compliant (or, actually, conformant) if it also supports int main().
There is no actual definition in the standard of what compliant means for code (or for a programmer).
If you mean that code which uses void main() is well-formed (the C++ standard defines a well-formed program to be "a C++ program constructed according to the syntax rules, diagnosable semantic rules, and the One Definition Rule") then you are potentially correct, whether an implementation is freestanding or hosted.
Although usage of void main() is likely to be diagnosed - by either the compiler or the linker - if the compiler does not specifically support void main().
Last edited by grumpy; 11-26-2010 at 03:40 AM.
That is an interesting observation. I assumed that "in a freestanding environment, start-up and termination is implementation-defined" meant that, like in C, "in a freestanding environment, the name and type of the function called at program startup are implementation-defined", but the statement that "all implementations shall allow both of the following definitions of main" clearly contradicts such an assumption.
What does "start-up and termination is implementation-defined" really mean, then? All that is offered as elaboration is the statement that "startup contains the execution of constructors for objects of namespace scope with static storage duration; termination contains the execution of destructors for objects with static storage duration".
Look up a C++ Reference and learn How To Ask Questions The Smart Way
Unless there is an argument here on why to use "void main" I don't think there is a real debate.
Yep. My guess is that the standards committee had a philosophy of allowing as much freedom as possible, while having to specify (at least) a minimum set of requirements that an implementation must meet. Those types of goals imply some contradiction or trade-off.
My interpretation is that startup is the process the implementation orchestrates before the first statement in main() (or any other entry point). That includes initialising standard I/O streams (stdout/cout, stdin/cin, etc), the process of ensuring constructors of objects with static storage duration are executed, and the process of preparing to call (and then calling) main().
Similarly, I would interpret termination as the process that the implementation orchestrates after main() returns (capturing the return value from main() so it can be returned to the host environment, invoking destructors of objects with static storage duration, closing standard I/O streams, etc).
